package common.utils;

import java.util.Collection;
import java.util.Map;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * Optional工具类，用于处理空值和预防空指针异常
 */
public class OptionalUtil {

    /**
     * 安全地获取对象的属性，避免空指针异常
     * @param obj 源对象
     * @param mapper 属性映射函数
     * @param defaultValue 默认值
     * @return 属性值或默认值
     */
    public static <T, R> R getOrDefault(T obj, Function<T, R> mapper, R defaultValue) {
        return Optional.ofNullable(obj)
                .map(mapper)
                .orElse(defaultValue);
    }
    
    /**
     * 安全地获取对象的属性，空值时返回null
     * @param obj 源对象
     * @param mapper 属性映射函数
     * @return 属性值或null
     */
    public static <T, R> R getOrNull(T obj, Function<T, R> mapper) {
        return getOrDefault(obj, mapper, null);
    }
    
    /**
     * 安全地执行消费者操作，当对象不为空时
     * @param obj 源对象
     * @param consumer 消费者操作
     */
    public static <T> void ifPresent(T obj, Consumer<T> consumer) {
        Optional.ofNullable(obj).ifPresent(consumer);
    }
    
    /**
     * 检查集合是否为空
     * @param collection 集合
     * @return 集合为null或空时返回true
     */
    public static boolean isEmpty(Collection<?> collection) {
        return collection == null || collection.isEmpty();
    }
    
    /**
     * 检查集合是否不为空
     * @param collection 集合
     * @return 集合不为null且不为空时返回true
     */
    public static boolean isNotEmpty(Collection<?> collection) {
        return !isEmpty(collection);
    }
    
    /**
     * 检查字符串是否为空
     * @param str 字符串
     * @return 字符串为null或空时返回true
     */
    public static boolean isEmpty(String str) {
        return str == null || str.trim().isEmpty();
    }
    
    /**
     * 检查字符串是否不为空
     * @param str 字符串
     * @return 字符串不为null且不为空时返回true
     */
    public static boolean isNotEmpty(String str) {
        return !isEmpty(str);
    }
    
    /**
     * 检查Map是否为空
     * @param map Map对象
     * @return Map为null或空时返回true
     */
    public static boolean isEmpty(Map<?, ?> map) {
        return map == null || map.isEmpty();
    }
    
    /**
     * 检查Map是否不为空
     * @param map Map对象
     * @return Map不为null且不为空时返回true
     */
    public static boolean isNotEmpty(Map<?, ?> map) {
        return !isEmpty(map);
    }
    
    /**
     * 检查数组是否为空
     * @param array 数组
     * @return 数组为null或长度为0时返回true
     */
    public static boolean isEmpty(Object[] array) {
        return array == null || array.length == 0;
    }
    
    /**
     * 检查数组是否不为空
     * @param array 数组
     * @return 数组不为null且长度大于0时返回true
     */
    public static boolean isNotEmpty(Object[] array) {
        return !isEmpty(array);
    }
    
    /**
     * 安全地执行函数，如果异常则返回默认值
     * @param supplier 函数
     * @param defaultValue 默认值
     * @return 函数结果或默认值
     */
    public static <T> T safeExecute(Supplier<T> supplier, T defaultValue) {
        try {
            return supplier.get();
        } catch (Exception e) {
            return defaultValue;
        }
    }
    
    /**
     * 检查对象是否为null
     * @param obj 对象
     * @return 对象不为null返回对象本身，否则抛出IllegalArgumentException
     */
    public static <T> T requireNonNull(T obj, String message) {
        if (obj == null) {
            throw new IllegalArgumentException(message);
        }
        return obj;
    }
    
    /**
     * 检查条件是否为true
     * @param condition 条件
     * @param message 错误消息
     * @throws IllegalArgumentException 条件为false时抛出异常
     */
    public static void require(boolean condition, String message) {
        if (!condition) {
            throw new IllegalArgumentException(message);
        }
    }
} 